<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>C语言基础 - 作用域与存储类</title>
    <link rel="stylesheet" href="common.css">
    <style>
        /* 页面特有样式 */
        .scope-card {
            background-color: #f5f9ff;
            border-radius: 8px;
            padding: 20px;
            margin-bottom: 25px;
            border-left: 4px solid #5D9CEC;
        }
        
        .variable-box {
            background-color: #f0f7ff;
            padding: 15px;
            border-radius: 5px;
            margin: 15px 0;
        }
        
        .storage-class-box {
            background-color: #fff3e0;
            padding: 15px;
            border-radius: 5px;
            margin: 15px 0;
        }
        
        .lifecycle-box {
            background-color: #e8f5e9;
            padding: 15px;
            border-radius: 5px;
            margin: 15px 0;
        }
        
        .comparison-table {
            width: 100%;
            margin: 15px 0;
            border-collapse: collapse;
        }
        
        .warning-note {
            background-color: #ffebee;
            border-left: 4px solid #f44336;
            padding: 12px;
            margin: 15px 0;
        }
        
        .best-practice {
            background-color: #e3f2fd;
            padding: 12px;
            border-left: 4px solid #2196F3;
            margin: 15px 0;
        }
    </style>
</head>
<body>
    <div class="container">
        <header>
            <h1>C语言基础入门课程</h1>
        </header>
        
        <nav>
            <a href="index.html">首页</a>
            <a href="02-intro.html">C语言简介与环境搭建</a>
            <a href="03-structure.html" class="current">C程序结构</a>
            <a href="04-datatypes.html">基本数据类型</a>
            <a href="05-variables.html">变量与常量</a>
            <a href="06-operators.html">运算符</a>
            <a href="07-io.html" class="current">输入输出</a>
            <a href="08-conditionals.html">条件语句</a>
            <a href="09-loops.html">循环结构</a>
            <a href="10-functions.html" class="current">函数基础</a>
            <a href="11-scope.html">作用域与存储类</a>
            <a href="12-recursion.html">递归函数</a>
            <a href="13-arrays.html">一维数组</a>
            <a href="14-multidim.html" class="current">多维数组</a>
            <a href="15-strings.html">字符串处理</a>
            <a href="16-pointers.html">指针基础</a>
            <a href="17-pointers_advanced.html" class="current">指针进阶</a>
            <a href="18-structs.html">结构体</a>
            <a href="19-files.html">文件操作</a>
            <a href="20-project.html">综合项目</a>
        </nav>
        
        <main>
            <h2>作用域与存储类</h2>
            
            <section>
                <h3>基本概念</h3>
                <p>作用域和存储类决定了变量的可见性和生命周期，是理解C语言内存管理的基础。</p>
            </section>
            
            <div class="scope-card">
                <h3>1. 局部变量与全局变量</h3>
                
                <div class="variable-box">
                    <h4>局部变量</h4>
                    <ul>
                        <li>在函数或代码块内部定义</li>
                        <li>只在定义它的块内可见</li>
                        <li>每次进入块时创建，退出时销毁</li>
                        <li>默认存储在栈上</li>
                    </ul>
                    <pre><code>void function() {
    int localVar = 10;  // 局部变量
    printf("%d", localVar);
}</code></pre>
                </div>
                
                <div class="variable-box">
                    <h4>全局变量</h4>
                    <ul>
                        <li>在所有函数外部定义</li>
                        <li>从定义点到文件末尾都可见</li>
                        <li>程序启动时创建，结束时销毁</li>
                        <li>存储在静态存储区</li>
                    </ul>
                    <pre><code>int globalVar = 20;  // 全局变量

void function1() {
    globalVar++;  // 可以访问
}

void function2() {
    printf("%d", globalVar);  // 可以访问
}</code></pre>
                </div>
                
                <table class="comparison-table">
                    <tr>
                        <th>比较项</th>
                        <th>局部变量</th>
                        <th>全局变量</th>
                    </tr>
                    <tr>
                        <td>定义位置</td>
                        <td>函数/代码块内部</td>
                        <td>所有函数外部</td>
                    </tr>
                    <tr>
                        <td>作用域</td>
                        <td>定义它的块内</td>
                        <td>定义点到文件末尾</td>
                    </tr>
                    <tr>
                        <td>生命周期</td>
                        <td>进入块时创建，退出时销毁</td>
                        <td>程序启动时创建，结束时销毁</td>
                    </tr>
                    <tr>
                        <td>存储位置</td>
                        <td>栈</td>
                        <td>静态存储区</td>
                    </tr>
                    <tr>
                        <td>初始化</td>
                        <td>默认值不确定</td>
                        <td>默认初始化为0</td>
                    </tr>
                </table>
                
                <div class="warning-note">
                    <h4>注意事项</h4>
                    <ul>
                        <li>避免过度使用全局变量，会增加耦合度</li>
                        <li>局部变量可以隐藏同名的全局变量</li>
                        <li>全局变量会增加内存占用时间</li>
                    </ul>
                </div>
            </div>
            
            <div class="scope-card">
                <h3>2. static与extern</h3>
                
                <div class="storage-class-box">
                    <h4>static关键字</h4>
                    <p>static有两种用法：</p>
                    
                    <h5>1. 静态局部变量</h5>
                    <ul>
                        <li>生命周期延长到整个程序运行期间</li>
                        <li>只在定义它的函数内可见</li>
                        <li>只初始化一次</li>
                    </ul>
                    <pre><code>void counter() {
    static int count = 0;  // 静态局部变量
    count++;
    printf("调用次数: %d\n", count);
}

int main() {
    counter();  // 输出1
    counter();  // 输出2
    counter();  // 输出3
    return 0;
}</code></pre>
                    
                    <h5>2. 静态全局变量/函数</h5>
                    <ul>
                        <li>限制作用域在当前文件</li>
                        <li>避免与其他文件的同名变量/函数冲突</li>
                    </ul>
                    <pre><code>// file1.c
static int hiddenVar = 42;  // 只能在file1.c中访问

static void hiddenFunc() {  // 只能在file1.c中调用
    printf("这是一个隐藏函数\n");
}</code></pre>
                </div>
                
                <div class="storage-class-box">
                    <h4>extern关键字</h4>
                    <ul>
                        <li>声明在其他文件中定义的全局变量或函数</li>
                        <li>用于多文件项目的变量共享</li>
                        <li>不分配存储空间，只是声明</li>
                    </ul>
                    <pre><code>// file1.c
int sharedVar = 100;  // 定义全局变量

// file2.c
extern int sharedVar;  // 声明在其他文件中定义的变量

void function() {
    printf("%d", sharedVar);  // 可以访问
}</code></pre>
                </div>
                
                <div class="best-practice">
                    <h4>使用建议</h4>
                    <ul>
                        <li>使用static限制不需要导出的变量和函数</li>
                        <li>extern声明应放在头文件中</li>
                        <li>避免在多文件中修改同一个全局变量</li>
                    </ul>
                </div>
            </div>
            
            <div class="scope-card">
                <h3>3. 变量生命周期</h3>
                
                <div class="lifecycle-box">
                    <h4>自动存储期(auto)</h4>
                    <ul>
                        <li>普通局部变量的默认存储类</li>
                        <li>进入块时创建，退出时销毁</li>
                        <li>存储在栈上</li>
                    </ul>
                    <pre><code>void function() {
    auto int x = 5;  // auto可省略
    printf("%d", x);
}</code></pre>
                </div>
                
                <div class="lifecycle-box">
                    <h4>静态存储期(static)</h4>
                    <ul>
                        <li>全局变量和静态局部变量的存储类</li>
                        <li>程序启动时创建，结束时销毁</li>
                        <li>存储在静态存储区</li>
                        <li>默认初始化为0</li>
                    </ul>
                    <pre><code>static int persistent = 0;  // 静态存储期

void function() {
    static int count = 0;  // 静态存储期
    count++;
}</code></pre>
                </div>
                
                <div class="lifecycle-box">
                    <h4>动态存储期(malloc/free)</h4>
                    <ul>
                        <li>通过malloc分配的内存</li>
                        <li>生命周期由程序员控制</li>
                        <li>存储在堆上</li>
                        <li>必须手动释放，否则会导致内存泄漏</li>
                    </ul>
                    <pre><code>int *createArray(int size) {
    int *arr = (int*)malloc(size * sizeof(int));
    return arr;
}

void useArray() {
    int *myArray = createArray(10);
    // 使用数组...
    free(myArray);  // 必须释放
}</code></pre>
                </div>
                
                <div class="warning-note">
                    <h4>内存区域比较</h4>
                    <table class="comparison-table">
                        <tr>
                            <th>存储区域</th>
                            <th>存储内容</th>
                            <th>管理方式</th>
                            <th>生命周期</th>
                        </tr>
                        <tr>
                            <td>栈(stack)</td>
                            <td>局部变量</td>
                            <td>自动</td>
                            <td>函数调用期间</td>
                        </tr>
                        <tr>
                            <td>堆(heap)</td>
                            <td>动态分配内存</td>
                            <td>手动(malloc/free)</td>
                            <td>分配后到释放前</td>
                        </tr>
                        <tr>
                            <td>静态存储区</td>
                            <td>全局/静态变量</td>
                            <td>自动</td>
                            <td>整个程序运行期间</td>
                        </tr>
                    </table>
                </div>
            </div>
            
            <section>
                <h3>综合示例</h3>
                <pre><code>#include &lt;stdio.h&gt;

// 全局变量(静态存储期)
int globalCount = 0;

// 函数声明
void increment();
void showCount();

int main() {
    // 自动存储期
    for (int i = 0; i < 5; i++) {
        increment();
    }
    showCount();
    return 0;
}

void increment() {
    // 静态局部变量
    static int staticCount = 0;
    
    // 自动局部变量
    int localCount = 0;
    
    globalCount++;
    staticCount++;
    localCount++;
    
    printf("global: %d, static: %d, local: %d\n",
           globalCount, staticCount, localCount);
}

void showCount() {
    printf("最终全局计数: %d\n", globalCount);
    // printf("%d", staticCount);  // 错误，staticCount不可见
}</code></pre>
            </section>
        </main>
        
        <footer>
             <p>&copy; </p>
        </footer>
        
        <!-- 二维码区域 -->

    </div> <!-- 结束.container -->
</body>
</html>